package com.huitongmaoyi.ai.service;

import com.huitongmaoyi.ai.entity.Customer;
import com.huitongmaoyi.ai.entity.DemandCriteria;
import com.huitongmaoyi.ai.util.DBMetadataUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;
import java.io.PrintWriter;

/**
 * 增强版纯对话式客户匹配服务（优化用户体验和容错性）
 */
public class CustomerService {
    private final String CUSTOMER_TABLE = "customers";

    // 数据库字段配置
    private final List<String> ENUM_COLUMNS = Arrays.asList("country_code", "industry", "credit_rating");
    private final List<String> NUMERIC_COLUMNS = Arrays.asList("annual_order_value", "risk_level");

    // 数据库元数据缓存
    private Map<String, Set<String>> enumFieldValues;
    private Map<String, double[]> numericFieldRanges;

    // 中文-数据库字段映射表
    private static final Map<String, String> COUNTRY_MAP = new HashMap<>();
    private static final Map<String, String> INDUSTRY_MAP = new HashMap<>();
    static {
        // 国家映射（中文 -> 数据库代码）
        COUNTRY_MAP.put("德国", "DE");
        COUNTRY_MAP.put("日本", "JP");
        COUNTRY_MAP.put("中国", "CN");
        COUNTRY_MAP.put("法国", "FR");
        COUNTRY_MAP.put("美国", "US");
        // 增加常见别名映射1
        COUNTRY_MAP.put(" Deutschland", "DE"); // 德语德国
        COUNTRY_MAP.put("米国", "US"); // 日语美国
        COUNTRY_MAP.put("华夏", "CN"); // 中文别名

        // 行业映射（中文 -> 数据库值）
        INDUSTRY_MAP.put("灯具", "Lights");
        INDUSTRY_MAP.put("建材", "Building Materials");
        INDUSTRY_MAP.put("电子", "Electronics");
        INDUSTRY_MAP.put("装饰", "Decor");
        INDUSTRY_MAP.put("家具", "Furniture");
        // 增加行业别名
        INDUSTRY_MAP.put("照明", "Lights");
        INDUSTRY_MAP.put("家电", "Electronics");
        INDUSTRY_MAP.put("装潢", "Decor");
    }

    // 引导话术模板（增强用户体验）
    private static final String[] GUIDE_PHRASES = {
            "为了更精准地帮您匹配客户，我们先确认几个关键信息哦~",
            "这些信息能帮助我们筛选出最适合您的外贸客户呢",
            "完成这几个问题后，我会立刻为您展示匹配结果~"
    };

    private final PrintWriter out; // 给客户端的输出流（关键新增）

    // 新增：接收 PrintWriter 的构造函数（服务器端调用时传入）
    public CustomerService(PrintWriter out) {
        this.out = out;
        this.enumFieldValues = DBMetadataUtil.getEnumFieldValues(CUSTOMER_TABLE, ENUM_COLUMNS);
        this.numericFieldRanges = DBMetadataUtil.getNumericFieldRanges(CUSTOMER_TABLE, NUMERIC_COLUMNS);
    }

    // 保留原有无参构造函数（兼容其他场景）
    public CustomerService() {
        this.out = null;
        this.enumFieldValues = DBMetadataUtil.getEnumFieldValues(CUSTOMER_TABLE, ENUM_COLUMNS);
        this.numericFieldRanges = DBMetadataUtil.getNumericFieldRanges(CUSTOMER_TABLE, NUMERIC_COLUMNS);
    }

    /**
     * 启动增强版对话式交互（所有输出替换为 out.println）
     */
    public void startConversation(Scanner scanner) {
        // 优先使用 Socket 输出流，无则用 System.out（兼容两种场景）
        PrintWriter output = out != null ? out : new PrintWriter(System.out, true);

        // 更友好的开场白
        output.println("🤖 您好！我是您的专属外贸客户匹配助手~");
        output.println("我可以帮您快速找到符合需求的海外客户，只需几个简单问题就行啦！");
        output.println(GUIDE_PHRASES[new Random().nextInt(GUIDE_PHRASES.length)]);

        DemandCriteria criteria = new DemandCriteria();

        // 分步引导，每个步骤增加容错和引导
        askCountry(scanner, criteria, output);
        askIndustry(scanner, criteria, output);
        askAnnualOrder(scanner, criteria, output);
        askRiskLevel(scanner, criteria, output);

        // 查询并展示结果
        List<Customer> results = queryCustomers(criteria);
        showResults(results, criteria, output);
    }

    /**
     * 询问目标国家（增强版：处理无关问题）
     */
    private void askCountry(Scanner scanner, DemandCriteria criteria, PrintWriter output) {
        Set<String> availableCountries = enumFieldValues.getOrDefault("country_code", new HashSet<>());
        String countryList = COUNTRY_MAP.keySet().toString();

        while (criteria.getCountry() == null) {
            output.println("\n💬 第一个问题：您希望开发哪个国家/地区的客户呢？");
            output.println("我们目前覆盖的主要市场有：" + countryList + "（直接说国家名或代码都可以哦）");
            String input = scanner.nextLine().trim();

            // 处理空输入
            if (input.isEmpty()) {
                output.println("😅 国家信息不能为空呢，请告诉我您想开发的市场~");
                continue;
            }

            // 处理无关问题（引导回主题）
            if (isIrrelevantQuestion(input)) {
                output.println("😊 您问的这个问题很有意思呢~ 不过当前我们正在匹配客户，先告诉我您想开发的国家，好吗？");
                continue;
            }

            // 智能匹配国家
            String countryCode = matchCountry(input, availableCountries);
            if (countryCode != null) {
                criteria.setCountry(countryCode);
                output.println("👍 已记录：目标国家 - " + countryCode + "（下一步我们看看行业信息吧~）");
            } else {
                output.println("😕 暂时没找到这个国家的客户资源呢，您可以从这些市场中选择：" + countryList);
            }
        }
    }

    /**
     * 询问目标行业（增强版：处理模糊输入）
     */
    private void askIndustry(Scanner scanner, DemandCriteria criteria, PrintWriter output) {
        Set<String> availableIndustries = enumFieldValues.getOrDefault("industry", new HashSet<>());
        String industryList = INDUSTRY_MAP.keySet().toString();

        while (criteria.getIndustry() == null) {
            output.println("\n💬 第二个问题：客户所属的行业是？");
            output.println("我们的客户主要分布在这些行业：" + industryList + "（可以说中文名称哦）");
            String input = scanner.nextLine().trim();

            if (input.isEmpty()) {
                output.println("😅 行业信息很重要呢，请告诉我您关注的行业~");
                continue;
            }

            if (isIrrelevantQuestion(input)) {
                output.println("😊 这个问题我们之后可以详细聊~ 现在先确定客户的行业，好吗？");
                continue;
            }

            // 智能匹配行业
            String industry = matchIndustry(input, availableIndustries);
            if (industry != null) {
                criteria.setIndustry(industry);
                output.println("👍 已记录：目标行业 - " + industry + "（接下来看看订单额要求吧~）");
            } else {
                output.println("😕 这个行业的客户暂时不多呢，您可以从这些行业中选择：" + industryList);
            }
        }
    }

    /**
     * 询问年订单额（增强版：更灵活的输入处理）
     */
    private void askAnnualOrder(Scanner scanner, DemandCriteria criteria, PrintWriter output) {
        double[] range = numericFieldRanges.getOrDefault("annual_order_value", new double[]{0, 10000});
        String rangeDesc = (int) range[0] + "-" + (int) range[1] + "万美金";

        while (true) {
            output.println("\n💬 第三个问题：对客户的年订单额有要求吗？");
            output.println("目前客户的年订单额范围在：" + rangeDesc);
            output.println("您可以说：500万以上 / 100-500万 / 无要求（直接回车也行哦）");
            String input = scanner.nextLine().trim();

            if (input.isEmpty()) {
                output.println("👍 已记录：年订单额无特定要求");
                break;
            }

            if (isIrrelevantQuestion(input)) {
                output.println("😊 关于订单额的其他问题我可以之后解答~ 您现在有具体的数值要求吗？");
                continue;
            }

            // 灵活解析输入（支持"以上""以下""之间"等表述）
            if (parseAnnualOrder(input, criteria)) {
                output.println("👍 已记录订单额要求（最后我们看看风险等级吧~）");
                break;
            } else {
                output.println("😕 格式有点看不懂呢，您可以试试说：500万以上 或 100-500万");
            }
        }
    }

    /**
     * 询问风险等级（增强版：更通俗的解释）
     */
    private void askRiskLevel(Scanner scanner, DemandCriteria criteria, PrintWriter output) {
        double[] range = numericFieldRanges.getOrDefault("risk_level", new double[]{1, 5});
        String rangeDesc = (int) range[0] + "-" + (int) range[1] + "级（1级最低，5级最高）";

        while (true) {
            output.println("\n💬 最后一个问题：对客户的风险等级有要求吗？");
            output.println("风险等级说明：" + rangeDesc + "，等级越低越安全哦");
            output.println("您可以说：3级以下 / 低风险 / 无要求（直接回车也行哦）");
            String input = scanner.nextLine().trim();

            if (input.isEmpty()) {
                output.println("👍 已记录：风险等级无特定要求");
                break;
            }

            if (isIrrelevantQuestion(input)) {
                output.println("😊 风险等级的具体评估标准我可以之后告诉您~ 现在有明确的等级要求吗？");
                continue;
            }

            // 解析风险等级（支持"低/中/高风险"等通俗表述）
            if (parseRiskLevel(input, criteria, range)) {
                output.println("👍 已记录风险等级要求");
                break;
            } else {
                output.println("😕 不太明白您的要求呢，您可以试试说：3级以下 或 低风险");
            }
        }
    }

    // ------------------------------ 工具方法 ------------------------------

    /**
     * 判断输入是否为无关问题（不是需求信息，而是疑问/闲聊）
     */
    private boolean isIrrelevantQuestion(String input) {
        // 包含疑问词且不包含业务关键词的视为无关问题
        String[] questionWords = {"什么", "为什么", "怎么", "如何", "吗", "呢", "？"};
        String[] businessKeywords = {"国家", "行业", "订单", "金额", "风险", "等级", "DE", "US", "JP"};

        boolean hasQuestionWord = Arrays.stream(questionWords).anyMatch(input::contains);
        boolean hasBusinessKeyword = Arrays.stream(businessKeywords).anyMatch(input::contains);

        return hasQuestionWord && !hasBusinessKeyword;
    }

    /**
     * 智能匹配国家（支持别名、拼音首字母等）
     */
    private String matchCountry(String input, Set<String> availableCountries) {
        // 1. 精确匹配中文
        if (COUNTRY_MAP.containsKey(input)) {
            return COUNTRY_MAP.get(input);
        }
        // 2. 匹配代码
        if (availableCountries.contains(input)) {
            return input;
        }
        // 3. 模糊匹配（如"美"→"US"）
        for (Map.Entry<String, String> entry : COUNTRY_MAP.entrySet()) {
            if (entry.getKey().contains(input) || input.contains(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }

    /**
     * 智能匹配行业（支持别名、模糊匹配）
     */
    private String matchIndustry(String input, Set<String> availableIndustries) {
        // 1. 精确匹配中文
        if (INDUSTRY_MAP.containsKey(input)) {
            return INDUSTRY_MAP.get(input);
        }
        // 2. 匹配行业值
        if (availableIndustries.contains(input)) {
            return input;
        }
        // 3. 模糊匹配（如"灯"→"Lights"）
        for (Map.Entry<String, String> entry : INDUSTRY_MAP.entrySet()) {
            if (entry.getKey().contains(input) || input.contains(entry.getKey())) {
                return entry.getValue();
            }
        }
        return null;
    }

    /**
     * 灵活解析年订单额输入（支持多种表述）
     */
    private boolean parseAnnualOrder(String input, DemandCriteria criteria) {
        try {
            input = input.replace("万", "").replace("美金", "").replace("美元", "").trim();
            // 处理"500以上"
            if (input.contains("以上")) {
                double min = Double.parseDouble(input.replace("以上", "").trim());
                criteria.setMinAnnualOrder(min);
                return true;
            }
            // 处理"500以下"
            if (input.contains("以下")) {
                double max = Double.parseDouble(input.replace("以下", "").trim());
                criteria.setMaxAnnualOrder(max);
                return true;
            }
            // 处理"100-500"
            if (input.contains("-")) {
                String[] parts = input.split("-");
                criteria.setMinAnnualOrder(Double.parseDouble(parts[0].trim()));
                criteria.setMaxAnnualOrder(Double.parseDouble(parts[1].trim()));
                return true;
            }
            // 处理纯数字（默认视为最小值）
            double min = Double.parseDouble(input);
            criteria.setMinAnnualOrder(min);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 解析风险等级（支持通俗表述）
     */
    private boolean parseRiskLevel(String input, DemandCriteria criteria, double[] range) {
        try {
            // 处理"低/中/高风险"
            if (input.contains("低")) {
                criteria.setMaxRiskLevel(2);
                return true;
            }
            if (input.contains("中")) {
                criteria.setMaxRiskLevel(3);
                return true;
            }
            if (input.contains("高")) {
                criteria.setMaxRiskLevel(5);
                return true;
            }
            // 处理"3级以下"
            if (input.contains("以下") || input.contains("≤")) {
                int max = Integer.parseInt(input.replaceAll("[^0-9]", "").trim());
                criteria.setMaxRiskLevel(max);
                return true;
            }
            // 处理纯数字
            int max = Integer.parseInt(input.replaceAll("[^0-9]", "").trim());
            if (max >= range[0] && max <= range[1]) {
                criteria.setMaxRiskLevel(max);
                return true;
            }
        } catch (Exception e) {
            return false;
        }
        return false;
    }

    /**
     * 查询客户（保持不变）
     */
    private List<Customer> queryCustomers(DemandCriteria criteria) {
        String sql = "SELECT id, name, country_code, city, industry, annual_order_value, " +
                "last_contact_days, contact_person, email, phone, address, " +
                "payment_terms, credit_rating, risk_level, notes " +
                "FROM customers WHERE 1=1";

        List<Object> params = new ArrayList<>();

        if (criteria.getCountry() != null) {
            sql += " AND country_code = ?";
            params.add(criteria.getCountry());
        }
        if (criteria.getIndustry() != null) {
            sql += " AND industry = ?";
            params.add(criteria.getIndustry());
        }
        if (criteria.getMinAnnualOrder() != null) {
            sql += " AND annual_order_value >= ?";
            params.add(criteria.getMinAnnualOrder());
        }
        if (criteria.getMaxAnnualOrder() != null) {
            sql += " AND annual_order_value <= ?";
            params.add(criteria.getMaxAnnualOrder());
        }
        if (criteria.getMaxRiskLevel() != null) {
            sql += " AND risk_level <= ?";
            params.add(criteria.getMaxRiskLevel());
        }

        sql += " ORDER BY annual_order_value DESC LIMIT 20";

        try (Connection conn = com.huitongmaoyi.ai.util.DBUtil.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            for (int i = 0; i < params.size(); i++) {
                stmt.setObject(i + 1, params.get(i));
            }

            ResultSet rs = stmt.executeQuery();
            List<Customer> customers = new ArrayList<>();
            while (rs.next()) {
                customers.add(new Customer(
                        rs.getString("id"),
                        rs.getString("name"),
                        rs.getString("country_code"),
                        rs.getString("city"),
                        rs.getString("industry"),
                        rs.getDouble("annual_order_value"),
                        rs.getInt("last_contact_days"),
                        rs.getString("contact_person"),
                        rs.getString("email"),
                        rs.getString("phone"),
                        rs.getString("address"),
                        rs.getString("payment_terms"),
                        rs.getString("credit_rating"),
                        rs.getInt("risk_level"),
                        rs.getString("notes")
                ));
            }
            return customers;
        } catch (SQLException e) {
            System.err.println("查询客户失败：" + e.getMessage()); // 服务器日志，用户看不到
            return new ArrayList<>();
        }
    }

    /**
     * 展示结果（优化格式）
     */
    private void showResults(List<Customer> results, DemandCriteria criteria, PrintWriter output) {
        output.println("\n📊 为您找到以下匹配的客户：");
        output.println("🔍 您的需求：国家=" + criteria.getCountry() + "，行业=" + criteria.getIndustry() +
                (criteria.getMinAnnualOrder() != null ? "，年订单额≥" + criteria.getMinAnnualOrder() + "万" : "") +
                (criteria.getMaxAnnualOrder() != null ? "，年订单额≤" + criteria.getMaxAnnualOrder() + "万" : "") +
                (criteria.getMaxRiskLevel() != null ? "，风险等级≤" + criteria.getMaxRiskLevel() : ""));
        output.println("------------------------------------------------------------------------------");

        if (results.isEmpty()) {
            output.println("😔 抱歉，没有找到完全匹配的客户。您可以尝试放宽条件再试一次~");
        } else {
            // 格式化表头
            output.printf("%-4s %-20s %-8s %-15s %-12s %-8s %-15s%n",
                    "序号", "公司名称", "国家", "城市", "年订单额(万)", "风险等级", "联系人");
            output.println("------------------------------------------------------------------------------");
            for (int i = 0; i < results.size(); i++) {
                Customer c = results.get(i);
                output.printf("%-4d %-20s %-8s %-15s %-12.1f %-8d %-15s%n",
                        i + 1, c.getName(), c.getCountryCode(), c.getCity(),
                        c.getAnnualOrderValue(), c.getRiskLevel(), c.getContactPerson());
            }
        }
        output.println("------------------------------------------------------------------------------");
        output.println("💡 如需查看客户详细联系方式，可以选择查看客户详情功能哦~");
    }
}